import type { Question } from '@/types/exam';

/**
 * 设计模式题目（初级10道 + 中级10道 + 高级10道）
 */
export const patternQuestions: Question[] = [
	// ========== 初级题目（10道） ==========
	{
		id: 7001,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '设计模式',
		question: '设计模式的主要目的是？',
		options: [
			{ key: 'A', text: '提高代码执行速度' },
			{ key: 'B', text: '解决常见的设计问题，提高代码复用性' },
			{ key: 'C', text: '减少代码行数' },
			{ key: 'D', text: '提高编译速度' }
		],
		answer: ['B'],
		explanation: '设计模式是解决常见软件设计问题的可复用方案，主要目的是提高代码的可维护性、可扩展性和复用性。'
	},
	{
		id: 7002,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '设计模式',
		question: '以下哪些属于创建型设计模式？',
		options: [
			{ key: 'A', text: '单例模式、工厂模式' },
			{ key: 'B', text: '观察者模式、策略模式' },
			{ key: 'C', text: '适配器模式、装饰器模式' },
			{ key: 'D', text: '代理模式、桥接模式' }
		],
		answer: ['A'],
		explanation: '创建型设计模式包括：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。它们关注对象的创建过程。'
	},
	{
		id: 7003,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '设计模式',
		question: '单例模式确保一个类只有一个实例。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '单例模式确保一个类只有一个实例，并提供全局访问点。常用于需要严格控制实例数量的场景。'
	},
	{
		id: 7004,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '设计模式',
		question: '工厂模式的主要作用是？',
		options: [
			{ key: 'A', text: '创建对象时隐藏具体实现' },
			{ key: 'B', text: '提高对象访问速度' },
			{ key: 'C', text: '减少内存占用' },
			{ key: 'D', text: '简化代码编译' }
		],
		answer: ['A'],
		explanation: '工厂模式通过工厂类创建对象，隐藏对象创建的具体实现，客户端只需要知道接口即可，提高了代码的灵活性和可维护性。'
	},
	{
		id: 7005,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '设计模式',
		question: '以下哪个是结构型设计模式？',
		options: [
			{ key: 'A', text: '单例模式' },
			{ key: 'B', text: '观察者模式' },
			{ key: 'C', text: '适配器模式' },
			{ key: 'D', text: '策略模式' }
		],
		answer: ['C'],
		explanation: '适配器模式是结构型设计模式，用于将不兼容的接口转换为兼容的接口。单例是创建型，观察者和策略是行为型。'
	},
	{
		id: 7006,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '设计模式',
		question: '观察者模式用于实现对象间的一对多依赖关系。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '观察者模式定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知并自动更新。'
	},
	{
		id: 7007,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '设计模式',
		question: '策略模式的主要优点是？',
		options: [
			{ key: 'A', text: '减少代码行数' },
			{ key: 'B', text: '可以在运行时动态切换算法' },
			{ key: 'C', text: '提高编译速度' },
			{ key: 'D', text: '减少内存占用' }
		],
		answer: ['B'],
		explanation: '策略模式定义一系列算法，把它们封装起来，并且使它们可互换。主要优点是在运行时可以动态切换算法，符合开闭原则。'
	},
	{
		id: 7008,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '设计模式',
		question: '装饰器模式的主要作用是？',
		options: [
			{ key: 'A', text: '创建对象' },
			{ key: 'B', text: '动态地给对象添加额外的职责' },
			{ key: 'C', text: '简化对象访问' },
			{ key: 'D', text: '提高对象性能' }
		],
		answer: ['B'],
		explanation: '装饰器模式允许动态地给对象添加额外的职责，比继承更灵活。它通过组合的方式扩展对象功能，而不是通过继承。'
	},
	{
		id: 7009,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: '设计模式',
		question: '代理模式可以为其他对象提供一种代理以控制对这个对象的访问。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: '代理模式为其他对象提供一种代理以控制对这个对象的访问。代理可以在访问对象前后添加额外操作，如权限检查、日志记录等。'
	},
	{
		id: 7010,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: '设计模式',
		question: '模板方法模式的主要特点是？',
		options: [
			{ key: 'A', text: '定义算法的骨架，将某些步骤延迟到子类实现' },
			{ key: 'B', text: '创建多个对象实例' },
			{ key: 'C', text: '简化对象接口' },
			{ key: 'D', text: '提高对象性能' }
		],
		answer: ['A'],
		explanation: '模板方法模式定义算法的骨架，将某些步骤延迟到子类实现。这样可以保持算法结构不变，同时允许子类重写特定步骤。'
	},

	// ========== 中级题目（10道） ==========
	{
		id: 7011,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: '设计模式',
		question: '以下哪些属于创建型设计模式？',
		options: [
			{ key: 'A', text: '单例模式' },
			{ key: 'B', text: '观察者模式' },
			{ key: 'C', text: '工厂模式' },
			{ key: 'D', text: '建造者模式' }
		],
		answer: ['A', 'C', 'D'],
		explanation: '创建型设计模式包括：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。观察者模式是行为型模式。'
	},
	{
		id: 7012,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '单例模式的饿汉式实现特点是？',
		options: [
			{ key: 'A', text: '在类加载时就创建实例' },
			{ key: 'B', text: '在第一次使用时才创建实例' },
			{ key: 'C', text: '每次调用都创建新实例' },
			{ key: 'D', text: '不允许创建实例' }
		],
		answer: ['A'],
		explanation: '饿汉式单例在类加载时就创建实例，线程安全但可能造成资源浪费。懒汉式在第一次使用时才创建，需要同步机制保证线程安全。'
	},
	{
		id: 7013,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '抽象工厂模式与工厂模式的主要区别是？',
		options: [
			{ key: 'A', text: '抽象工厂可以创建多个产品族' },
			{ key: 'B', text: '工厂模式创建速度更快' },
			{ key: 'C', text: '抽象工厂代码更简洁' },
			{ key: 'D', text: '没有区别' }
		],
		answer: ['A'],
		explanation: '抽象工厂模式可以创建多个产品族，而工厂模式只能创建一种产品。抽象工厂适合需要创建一系列相关或依赖对象的场景。'
	},
	{
		id: 7014,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '建造者模式的主要应用场景是？',
		options: [
			{ key: 'A', text: '创建简单对象' },
			{ key: 'B', text: '创建复杂对象，需要多个步骤配置' },
			{ key: 'C', text: '创建单个对象' },
			{ key: 'D', text: '销毁对象' }
		],
		answer: ['B'],
		explanation: '建造者模式适用于创建复杂对象，特别是需要多个步骤配置的对象。它通过链式调用逐步构建对象，使代码更清晰易读。'
	},
	{
		id: 7015,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '适配器模式的主要作用是？',
		options: [
			{ key: 'A', text: '创建对象' },
			{ key: 'B', text: '将不兼容的接口转换为兼容的接口' },
			{ key: 'C', text: '简化对象访问' },
			{ key: 'D', text: '提高对象性能' }
		],
		answer: ['B'],
		explanation: '适配器模式将不兼容的接口转换为兼容的接口，使原本不兼容的类可以协同工作。常用于集成第三方库或遗留系统。'
	},
	{
		id: 7016,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '组合模式的主要应用场景是？',
		options: [
			{ key: 'A', text: '处理简单对象' },
			{ key: 'B', text: '处理树形结构，统一对待单个对象和组合对象' },
			{ key: 'C', text: '创建单个对象' },
			{ key: 'D', text: '销毁对象' }
		],
		answer: ['B'],
		explanation: '组合模式用于处理树形结构，将单个对象和组合对象统一对待。客户端可以一致地处理单个对象和对象组合，简化操作。'
	},
	{
		id: 7017,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '门面（外观）模式的主要目的是？',
		options: [
			{ key: 'A', text: '增加系统复杂度' },
			{ key: 'B', text: '为子系统提供统一的简化接口' },
			{ key: 'C', text: '隐藏所有接口' },
			{ key: 'D', text: '提高系统性能' }
		],
		answer: ['B'],
		explanation: '门面模式为子系统中的一组接口提供统一的简化接口，隐藏子系统的复杂性，使客户端更容易使用子系统。'
	},
	{
		id: 7018,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '命令模式的主要优点是？',
		options: [
			{ key: 'A', text: '减少代码行数' },
			{ key: 'B', text: '将请求封装为对象，支持撤销、队列、日志等操作' },
			{ key: 'C', text: '提高编译速度' },
			{ key: 'D', text: '减少内存占用' }
		],
		answer: ['B'],
		explanation: '命令模式将请求封装为对象，使请求的参数化、队列化、日志记录和撤销操作成为可能。提高了系统的灵活性和可扩展性。'
	},
	{
		id: 7019,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: '设计模式',
		question: '以下哪些是行为型设计模式？',
		options: [
			{ key: 'A', text: '观察者模式' },
			{ key: 'B', text: '策略模式' },
			{ key: 'C', text: '模板方法模式' },
			{ key: 'D', text: '单例模式' }
		],
		answer: ['A', 'B', 'C'],
		explanation: '行为型设计模式关注对象之间的通信和职责分配，包括：观察者、策略、模板方法、命令、状态等。单例模式是创建型模式。'
	},
	{
		id: 7020,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: '设计模式',
		question: '状态模式的主要应用场景是？',
		options: [
			{ key: 'A', text: '处理简单状态' },
			{ key: 'B', text: '对象的行为依赖于其状态，且状态转换复杂' },
			{ key: 'C', text: '创建对象' },
			{ key: 'D', text: '销毁对象' }
		],
		answer: ['B'],
		explanation: '状态模式允许对象在内部状态改变时改变其行为。当对象的行为依赖于其状态，且状态转换复杂时，使用状态模式可以简化代码。'
	},

	// ========== 高级题目（10道） ==========
	{
		id: 7021,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '单例模式的枚举实现方式的主要优点是？',
		options: [
			{ key: 'A', text: '代码更简洁' },
			{ key: 'B', text: '线程安全、防止反射攻击、防止反序列化' },
			{ key: 'C', text: '性能更好' },
			{ key: 'D', text: '内存占用更少' }
		],
		answer: ['B'],
		explanation: '枚举单例是最安全的单例实现方式，天然线程安全，可以防止反射攻击和反序列化创建新实例，是Java推荐的单例实现方式。'
	},
	{
		id: 7022,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '代理模式与装饰器模式的主要区别是？',
		options: [
			{ key: 'A', text: '代理控制访问，装饰器扩展功能' },
			{ key: 'B', text: '没有区别' },
			{ key: 'C', text: '代理扩展功能，装饰器控制访问' },
			{ key: 'D', text: '代理创建对象，装饰器销毁对象' }
		],
		answer: ['A'],
		explanation: '代理模式控制对对象的访问（如权限检查、延迟加载），装饰器模式动态扩展对象功能。两者结构相似但目的不同。'
	},
	{
		id: 7023,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '责任链模式的主要特点是？',
		options: [
			{ key: 'A', text: '将请求沿着处理者链传递，直到有处理者处理它' },
			{ key: 'B', text: '创建对象链' },
			{ key: 'C', text: '简化对象访问' },
			{ key: 'D', text: '提高对象性能' }
		],
		answer: ['A'],
		explanation: '责任链模式将请求沿着处理者链传递，直到有处理者处理它。可以动态组织处理者，解耦请求发送者和接收者。'
	},
	{
		id: 7024,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '访问者模式的主要应用场景是？',
		options: [
			{ key: 'A', text: '处理简单对象' },
			{ key: 'B', text: '对象结构稳定，但需要经常添加新操作' },
			{ key: 'C', text: '创建对象' },
			{ key: 'D', text: '销毁对象' }
		],
		answer: ['B'],
		explanation: '访问者模式适用于对象结构稳定，但需要经常添加新操作的场景。它将操作与对象结构分离，新增操作时不需要修改对象结构。'
	},
	{
		id: 7025,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: '设计模式',
		question: '以下哪些设计模式属于GOF的23种设计模式？',
		options: [
			{ key: 'A', text: '单例模式' },
			{ key: 'B', text: '工厂模式' },
			{ key: 'C', text: '观察者模式' },
			{ key: 'D', text: 'MVC模式' }
		],
		answer: ['A', 'B', 'C'],
		explanation: 'GOF的23种设计模式包括：5种创建型、7种结构型、11种行为型。单例、工厂、观察者都是GOF模式。MVC是架构模式，不是GOF设计模式。'
	},
	{
		id: 7026,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '桥接模式的主要目的是？',
		options: [
			{ key: 'A', text: '创建对象' },
			{ key: 'B', text: '将抽象与实现分离，使它们可以独立变化' },
			{ key: 'C', text: '简化对象访问' },
			{ key: 'D', text: '提高对象性能' }
		],
		answer: ['B'],
		explanation: '桥接模式将抽象与实现分离，使它们可以独立变化。通过组合而不是继承来连接抽象和实现，提高了系统的灵活性。'
	},
	{
		id: 7027,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '解释器模式的主要应用场景是？',
		options: [
			{ key: 'A', text: '处理简单表达式' },
			{ key: 'B', text: '定义语法规则，解释语言或表达式' },
			{ key: 'C', text: '创建对象' },
			{ key: 'D', text: '销毁对象' }
		],
		answer: ['B'],
		explanation: '解释器模式定义语法规则，用于解释语言或表达式。适用于需要解释和执行特定语言的场景，如正则表达式、SQL解析等。'
	},
	{
		id: 7028,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '中介者模式的主要优点是？',
		options: [
			{ key: 'A', text: '增加对象间的直接依赖' },
			{ key: 'B', text: '减少对象间的直接通信，降低耦合度' },
			{ key: 'C', text: '简化对象创建' },
			{ key: 'D', text: '提高对象性能' }
		],
		answer: ['B'],
		explanation: '中介者模式通过引入中介者对象，减少对象间的直接通信，降低耦合度。对象之间通过中介者进行通信，使系统更容易维护和扩展。'
	},
	{
		id: 7029,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: '设计模式',
		question: '原型模式的主要应用场景是？',
		options: [
			{ key: 'A', text: '创建简单对象' },
			{ key: 'B', text: '创建对象成本较高，通过复制已有实例创建新实例' },
			{ key: 'C', text: '创建单个对象' },
			{ key: 'D', text: '销毁对象' }
		],
		answer: ['B'],
		explanation: '原型模式通过复制已有实例创建新实例，而不是通过构造函数创建。适用于创建对象成本较高的场景，如需要大量初始化工作或数据库查询。'
	},
	{
		id: 7030,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: '设计模式',
		question: '设计模式遵循的主要设计原则包括？',
		options: [
			{ key: 'A', text: '单一职责原则（SRP）' },
			{ key: 'B', text: '开闭原则（OCP）' },
			{ key: 'C', text: '里氏替换原则（LSP）' },
			{ key: 'D', text: '依赖倒置原则（DIP）' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: '设计模式遵循SOLID原则：单一职责（每个类只有一个职责）、开闭原则（对扩展开放，对修改关闭）、里氏替换（子类可替换父类）、接口隔离、依赖倒置（依赖抽象而非具体）。'
	}
];

